SpatialFear.SFWeapon

//=============================================================================
// Spatial Fear
// Class: SFTournamentWeapon
// Descripton: Subclasses of Tournament weapon
// modified to allow for behaviour adjustment required by SFPlayer class.
//
// Author: Markus Nuebel
//=============================================================================

class SFWeapon extends TournamentWeapon
	abstract;
// Some fixes and additions to UT weapons
var (Weapon) int MaxTargetRange; // Private: Range of fired projectiles and intant shots in UUs.
var (Weapon) int MaxTargetRangeAlt; // Private: Range of fired projectiles and instant shots in UUs. (ALT fire mode)


var (SpatialFear) travel int CreateTag; // Reference to players goaltable. If the tag is not -1 then the corrosponding goal is checked. If the goal was not reached already the pickup is destroyed during level entering. Default: -1

var (SpatialFear) float fNormalRate; // Amount of time, it takes to fire one shell with an PlayAnim rate of 1.0. Default: 0.33 (derived from Enforcer)
var (SpatialFear) float fDesiredRate; // Amount of time, it takes to fire one shell in seconds. Default: 0.33
var (SpatialFear) float fAltDesiredRate; // Amount of time, it takes to fire one shell in seconds. Default: 0.33 (AltMode)
var (SpatialFear) float fDamage; // Amout of damage this weapon does. Default: 20
var (SpatialFear) float fAltDamage; // Amout of damage this weapon does in alt mode. Default: 20
var (SpatialFear) int	AmmoPerShot; // Amount of ammo, used per shot. Default: 1
var (SpatialFear) int	AltAmmoPerShot; // Amount of ammo, used per shot in alt mode. Default: 1
var (SpatialFear) Texture Icon ; // Weapon icon displayed when the HUD upgrade module is equipped.
var (SpatialFear) travel bool	  bInstantHit;		 // If true, instant hit rather than projectile firing weapon
var (SpatialFear) float fMomentum; // Movment used for hit
var (SpatialFear) float fAltMomentum; // Movment used for alt hit
var (SpatialFear) bool bCanUpgradeLaserSight; // Determines, if this weapon can be upgraded with a Laser Sight, Default: false
var (SpatialFear) bool bCanUpgradeEnergyBooster; // Determines, if this weapon can be upgraded with an Energy Booster, Default: false
var (SpatialFear) string LaserSightUpgradeMessage; // Message displayed, when weapon is upgraded with the Laser Sight.
var (SpatialFear) string EnergyBoosterUpgradeMessage; // Message displayed, when weapon is upgraded with the EnergyBooster.
var (SpatialFear) Sound UpgradeWeaponSound; // Sound played when the weapon is upgraded.
var (SpatialFear) bool bShake; // Activates shaking  when fireing. Default: false
var (SpatialFear) bool bFlash; // Activates flashing, when fireing. Default: false
var (SpatialFear) float	ShakeMagAlt; // ShakeMag in secondary (alt) mode
var (SpatialFear) float	ShakeTimeAlt; // ShakeTimeAlt in secondary (alt) mode
var (SpatialFear) float ShakeVertAlt; // ShakeVertAlt in secondary (alt) mode
var (SpatialFear) float InstantFlashAlt; // Scale for an instant flash (alt) mode
var (SpatialFear) vector InstantFogAlt; // Vector for an instant flash (alt) mode
var (SpatialFear) bool bTrailEffect; // Spawn a trail effect for bInstantHit weapons. Default: false
var (SpatialFear) float m_fTrailEffectIntervallSize; // Size of intervall between single trail effects. Default: 125
var (SpatialFear) bool bAlienWeapon; // This flag is set to true for alien weapons, that cannot be used by a player

var class<Actor> m_clsHitWallEffect;	// Effect for wall hits
var class<Actor> m_clsSmokeEffect;	// Effect for body hits
var class<Effects> m_clsTrailEffect; // Effect for trail of bInstantHit weapon
var class<Actor> m_clsHitPawnEffect; // Effect for hitting a pawn
var float m_fCurrentRate; // Private: Current PlayAnim rate, calculated from normal and desired.
var float m_fAltCurrentRate; // Private: Current PlayAnim rate, calculated from normal and desired. (AltMode)
var bool m_bSemiAuto; // Private: Is this a semi-auto or an automatic weapon. Default: false
var bool m_bSemiAutoAlt; // Private: Semi-auto setting for ALT fire mode. Default: false
var bool m_bAltMode; // Private: Current fire mode;
var float AccuracyPenalty; // Private: Modified by SFPlayer class to adjust weapon accuracy.
var float m_fTangentCalc; // Maximum y-axis penalty ranged, calculated based on the tangent of 5 degree for max distance of this weapon. Default: 1000
var float m_fTangentCalcAlt; // Maximum y-axis penalty ranged, calculated based on the tangent of 5 degree for max distance of this weapon (Alt mode). Default: 1000
var bool m_bHasLaserSight; // Private: Marks, if the weapon has already installed the laser sight upgrade.
var bool m_bHasEnergyBooster; // Private: Marks, if the weapon has already installed the energy booster upgrade.

var int	nProjRange; // Private: Read only variable used for stats.
var float fProjLifeSpan; // Private: Read only variable used for stats.

Replication
{
	Reliable if ( bNetOwner && (Role == ROLE_Authority) )
		AccuracyPenalty;
}

// Events  //

// Called on entring play
event PostBeginPlay()
{
	// Call to base class
	Super.PostBeginPlay();

	// Calculate actual PlayAnim rate
	m_fCurrentRate = fNormalRate/fDesiredRate;
	m_fAltCurrentRate = fNormalRate/fAltDesiredRate;
	// Calculate the accuracy penalty
	m_fTangentCalc 		= MaxTargetRange/19.0811366; // tan(87) in degree
	m_fTangentCalcAlt	= MaxTargetRangeAlt/19.0811366; // tan(87) in degree
}

// Overwritten, to disable the automatic remove from the gameS
function BecomePickup()
{
	// Call to base class
	Super.BecomePickup();
	bHeldItem=false;
}

// Upgrades the weapon with the laser sight
function upgradeLaserSight()
{
	if(bCanUpgradeLaserSight)
	{
		// Do the upgrade
		m_bHasLaserSight	= true;
		// Reset the flag
		bCanUpgradeLaserSight=false;

		Pawn(Owner).ClientMessage(LaserSightUpgradeMessage);
		PlaySound(UpgradeWeaponSound, SLOT_None, Pawn(Owner).SoundDampening*3.0);

	}
}

// Upgrades the weapon with the energy booster
function upgradeEnergyBooster(float fAmount)
{
	if(bCanUpgradeEnergyBooster)
	{
		// Do the upgrade (15%)
		m_bHasEnergyBooster	= true;
		fDamage	*= 1 + fAmount;

		// Reset the flag
		bCanUpgradeEnergyBooster=false;

		Pawn(Owner).ClientMessage(EnergyBoosterUpgradeMessage);
		PlaySound(UpgradeWeaponSound, SLOT_None, Pawn(Owner).SoundDampening*3.0);
	}
}

// Spawns a configured smoke effect
function spawnSmokeEffect(vector HitLocation, vector HitNormal)
{
	if(None != m_clsSmokeEffect)
		spawn(m_clsSmokeEffect,,,HitLocation+HitNormal*9);
}

// Spawns a configured wallhit effect
function spawnWallHitEffect(vector HitLocation, vector HitNormal)
{
	if(None != m_clsHitWallEffect)
		Spawn(m_clsHitWallEffect,,, HitLocation+HitNormal, Rotator(HitNormal));
}

// Spawns a configured effect when a pawn or carcass is hit
function spawnPawnHitEffect(vector HitLocation, vector HitNormal)
{
	if(None != m_clsHitPawnEffect)
		Spawn(m_clsHitPawnEffect,,, HitLocation+HitNormal, Rotator(HitNormal));
}

// Simplified ProcessTraceHit, that handles a normal trace hit.
// Does not spawn a shellcase !!
function ProcessTraceHit(Actor Other, Vector HitLocation, Vector HitNormal, Vector X, Vector Y, Vector Z)
{
	local float fCurrentMomentum;

	if(!IsInState('AltFiring'))
		fCurrentMomentum = fMomentum;
	else
		fCurrentMomentum = fAltMomentum;

	// Check for level hit
	if (Other == Level)
	{
		spawnWallHitEffect(HitLocation, HitNormal);
	}
	else if ( (Other!=self) && (Other != None) )
	{
		// Hit something
		if ( !Other.bIsPawn && !Other.IsA('Carcass') )
		{
			spawnSmokeEffect(HitLocation, HitNormal);
			Other.TakeDamage(fDamage, Pawn(Owner), HitLocation, fCurrentMomentum*X, MyDamageType);
		}
		else
		{
			spawnPawnHitEffect(HitLocation, HitNormal);
			Other.TakeDamage(fDamage, Pawn(Owner), HitLocation, fCurrentMomentum*X, MyDamageType);
		}
	}
}

// Does a shake for the primary weapon mode
function ShakePrimary()
{
	PlayerPawn(Owner).ShakeView(ShakeTime, ShakeMag, ShakeVert);
}


// Does a flash for primary mode

function FlashPrimary()
{
	PlayerPawn(Owner).ClientInstantFlash(InstFlash, InstFog);
}

// Does a flash for secondary (alt) mode
function FlashSecondary()
{
	PlayerPawn(Owner).ClientInstantFlash( InstantFlashAlt, InstantFogAlt);
}

// Does a shake for the secondary weapon mode
function ShakeSecondary()
{
	PlayerPawn(Owner).ShakeView(ShakeTimeAlt, ShakeMagAlt, ShakeVertAlt);
}

// Can be overwritten in subclassed, that can be used as tools
function PlayUseKeyHit()
{
}

// Overwritten here to add SF features like range.
function TraceFire( float Accuracy )
{
	local vector HitLocation, HitNormal, StartTrace, EndTrace, X,Y,Z;
	local actor Other;
	local Pawn PawnOwner;
	local float fAimRange;
	local float	fMaxRange;

	// log("Trace Fire Accuracy: " $ Accuracy $ " AccuracyPenalty "$ AccuracyPenalty);

	// Update accuracy
/*
	if(!m_bHasLaserSight)
		Accuracy += AccuracyPenalty;
	else
		Accuracy = 0.01f;
*/
	if(!IsInState('AltFiring'))
	{
		fMaxRange	= MaxTargetRange;
		fAimRange	= AccuracyPenalty*m_fTangentCalc;
	}
	else
	{
		fMaxRange	= MaxTargetRangeAlt;
		fAimRange	= AccuracyPenalty*m_fTangentCalcAlt;
	}

	// Correct for laser sight
	if(m_bHasLaserSight)
		fAimRange	= 0;

	// log("AccuracyPenalty: " $ AccuracyPenalty $ " fAimRange: " $ fAimRange $ " m_fTangentCalc: " $ m_fTangentCalc);
	PawnOwner = Pawn(Owner);
	if(!PawnOwner.bIsPlayer)
		fAimRange /= 2.0f;

	Owner.MakeNoise(PawnOwner.SoundDampening);
	GetAxes(PawnOwner.ViewRotation,X,Y,Z);
	StartTrace = Owner.Location + CalcDrawOffset();// + FireOffset.X * X + FireOffset.Y * Y + FireOffset.Z * Z;
	AdjustedAim = PawnOwner.AdjustAim(1000000, StartTrace, 2*AimError, False, False);
	EndTrace = StartTrace +  (FRand() - 0.5 )* Y * fAimRange + (FRand() - 0.5 ) * Z * fAimRange;
	X = vector(AdjustedAim);

	// Take the range into account
	EndTrace += (fMaxRange * X);
	Other = PawnOwner.TraceShot(HitLocation,HitNormal,EndTrace,StartTrace);
	// Handle the trail effect here, since it depends on a valid Hitlocation
	if(None != Other)
		SpawnTrailEffect(m_clsTrailEffect, HitLocation,  Owner.Location + CalcDrawOffset() + FireOffset.X * X + FireOffset.Y * Y + FireOffset.Z * Z, m_fTrailEffectIntervallSize, 9999.0f);
	else
		SpawnTrailEffect(m_clsTrailEffect, EndTrace,  Owner.Location + CalcDrawOffset() + FireOffset.X * X + FireOffset.Y * Y + FireOffset.Z * Z, m_fTrailEffectIntervallSize, 9999.0f);

	// Call the hit routine
	ProcessTraceHit(Other, HitLocation, HitNormal, X,Y,Z);
}


// Calculates the projectile direction based on the current position and
// the current accuracy penalty
function vector calcProjectileDirection(Pawn Owner, vector vecStart, vector vecOwnerLocation, float fAccuracyError)
{
	local float	fAimError;
	local float	fAimRange;
	local float	fMaxRange;
	local Vector	vecEnd, X,Y,Z;

//147 = 1deg
//870 = 5deg

/*
	// Convert from fAccuracyError (given in degrees) to AimError
	// Aimerror of 1.0 equals 5 degrees, calculated by the tan on a triangle
	// of 10000 by 1000
	if(0.0f == fAccuracyError)
		fAimError = 0.0f;
	else
		fAimError	= fAccuracyError/5.0f;
*/
	if(!IsInState('AltFiring'))
	{
		fMaxRange	= MaxTargetRange;
		fAimRange	= AccuracyPenalty*m_fTangentCalc;
	}
	else
	{
		fMaxRange	= MaxTargetRangeAlt;
		fAimRange	= AccuracyPenalty*m_fTangentCalcAlt;
	}

	// Correct for laser sight
	if(m_bHasLaserSight)
		fAimRange	= 0;

	// Retrieve the current orientation
	GetAxes(Owner.ViewRotation,X,Y,Z);
	if(!Owner.bIsPlayer)
		fAimRange /= 2.0f;

	// Calculate the aiming direction with error
	//vecEnd	= vecStart + fAimError * (FRand() - 0.5 )* Y * 1000	+ fAimError* (FRand() - 0.5 ) * Z * 1000;
/*
	// Using the corrected position
	vecEnd	= vecOwnerLocation + (FRand() - 0.5 )* Y * fAimRange+ (FRand() - 0.5 ) * Z * fAimRange;

	// Add distance
	vecEnd += (10000 * vector(Owner.ViewRotation)) + 2*(vecOwnerLocation-vecStart);
*/
	vecEnd = vecStart +  (FRand() - 0.5 )* Y * fAimRange + (FRand() - 0.5 ) * Z * fAimRange;

	// Take the range into account
	vecEnd += (fMaxRange * X);

	// Distance is just the difference
	return(Normal(vecEnd-vecStart));
}

// Fires a projectile weapon. Standard implementation, that just releases
// an projectile. Special cases have to be handled in derived classes.
function Projectile ProjectileFire(class<projectile> ProjClass, float fProjSpeed, bool bWarn)
{

	local SFProjectile oProj;
	local Vector vecStart,X,Y,Z;
	local Vector vecDirection;
	local Vector test;

	// Make a noise, because we are fireing a weapon
	Owner.MakeNoise(Pawn(Owner).SoundDampening);

	// Extract the axis from the rotation
	GetAxes(Pawn(Owner).ViewRotation,X,Y,Z);

	// Calculate the start point
	vecStart = Owner.Location + CalcDrawOffset() + FireOffset.X * X + FireOffset.Y * Y + FireOffset.Z * Z;

	// Calculate the direction of the projectile
	if(!m_bHasLaserSight)
		vecDirection = calcProjectileDirection(Pawn(Owner), vecStart, Owner.Location, AccuracyPenalty);
	else
		vecDirection = calcProjectileDirection(Pawn(Owner), vecStart, Owner.Location, 0.01f);

	// Release the projectile
	oProj = SFProjectile(Spawn(ProjClass,,, vecStart, rotator(vecDirection)));

	// Set some projectile values
	if(!IsInState('AltFiring'))
	{
		oProj.setRange(MaxTargetRange);
		oProj.damage = fDamage;
	}
	else
	{
		oProj.setRange(MaxTargetRangeAlt);
		oProj.damage = fAltDamage;
	}

	nProjRange = oProj.Range;
	fProjLifeSpan = oProj.LifeSpan;


	return oProj;
}

function int getAmmoPerShot()
{

	// First check, which mode we are in
	if(!IsInState('AltFiring'))
		return AmmoPerShot;
	else
		return AltAmmoPerShot;
}

// Overwritten to cope with nAmmoPerShot
function float SwitchPriority()
{
	local float temp;
	local int bTemp;
	local int	nAmmoPerShot;

	nAmmoPerShot = getAmmoPerShot();

	if ( !Owner.IsA('PlayerPawn') )
		return RateSelf(bTemp);
	else if ( (AmmoType != None) && (AmmoType.AmmoAmount<=nAmmoPerShot) )
	{
		if ( Pawn(Owner).Weapon == self )
			return -0.5;
		else
			return -1;
	}
	else
	{
		return AutoSwitchPriority;
	}
}

// Spawns a trail effect
function Effects SpawnTrailEffect(class<Effects> TrailEffect, vector HitLocation,  vector SmokeLocation, float fIntervalSize, int nMaxIntervals)
{
	local Effects TEffect;
	local Vector DVector;
	local int NumPoints;
	local rotator SmokeRotation;

	// Some inits
	DVector			= HitLocation - SmokeLocation;
	NumPoints		= VSize(DVector)/fIntervalSize;

	// Some checks
	if ( NumPoints < 1 )
		return None;
	if( NumPoints > nMaxIntervals)
		NumPoints = nMaxIntervals;

	// Spawn the stuff
	SmokeRotation = rotator(DVector);
	SmokeRotation.roll = Rand(65535);

	TEffect = Spawn(TrailEffect,,,SmokeLocation,SmokeRotation);

	if(TEffect.IsA('ShockBeam'))
	{
		ShockBeam(TEffect).MoveAmount = DVector/NumPoints;
		ShockBeam(TEffect).NumPuffs = NumPoints - 1;
	}
	else if(TEffect.IsA('RingExplosion4'))
	{
		RingExplosion4(TEffect).MoveAmount = DVector/NumPoints;
		RingExplosion4(TEffect).NumPuffs = NumPoints - 1;
	}
	else if(TEffect.IsA('SFEffects'))
	{
		SFEffects(TEffect).MoveAmount = DVector/NumPoints;
		SFEffects(TEffect).NumPuffs = NumPoints - 1;
	}

	return TEffect;
}



//////////////////////////////////////////////
// States
//////////////////////////////////////////////

auto state Pickup
{
	// Overwritten Touch function, to get rid of the pickup messages
	function Touch( actor Other )
	{
		// If touched by a player pawn, let him pick this up.
		if( ValidTouch(Other) )
		{
			if (Level.Game.LocalLog != None)
				Level.Game.LocalLog.LogPickup(Self, Pawn(Other));
			if (Level.Game.WorldLog != None)
				Level.Game.WorldLog.LogPickup(Self, Pawn(Other));
			SpawnCopy(Pawn(Other));
			PlaySound (PickupSound);
			if ( Level.Game.Difficulty > 1 )
				Other.MakeNoise(0.1 * Level.Game.Difficulty);
			if ( Pawn(Other).MoveTarget == self )
				Pawn(Other).MoveTimer = -1.0;
		}
		else if ( bTossedOut && (Other.Class == Class)
				&& Inventory(Other).bTossedOut )
				Destroy();
	}

	singular function ZoneChange( ZoneInfo NewZone )
	{
		// Do entry actor and sound display only for non Radiation zones
		if(!NewZone.IsA('SFRadiationZone'))
			Super.ZoneChange(NewZone);
	}
}

function AltFire( float Value )
{
	// Ammocheck
	if ( (AmmoType == None) && (AmmoName != None) )
		GiveAmmo(Pawn(Owner));

	if (AmmoType.UseAmmo(AltAmmoPerShot))
	{
		GotoState('AltFiring');
		if ( PlayerPawn(Owner) != None )
		{
			if(bShake)
				ShakeSecondary();
			if(bFlash)
				FlashSecondary();
		}
		bPointing=True;
		PlayAltFiring();
		if ( !bRapidFire && (FiringSpeed > 0) )
			Pawn(Owner).PlayRecoil(FiringSpeed);
		if ( bAltInstantHit )
			TraceFire(Value);
		else
			ProjectileFire(AltProjectileClass, AltProjectileSpeed, bAltWarnTarget);
		if ( Owner.bHidden )
			CheckVisibility();
	}
	else
		GotoState('Idle');
}

function Fire( float Value )
{
	// Ammocheck
	if ( (AmmoType == None) && (AmmoName != None) )
		GiveAmmo(Pawn(Owner));
	if ( AmmoType.UseAmmo(AmmoPerShot) )
	{
		GotoState('NormalFire');
		if ( PlayerPawn(Owner) != None )
		{
			if(bShake)
				ShakePrimary();
			if(bFlash)
				FlashPrimary();
		}
		bPointing=True;
		bCanClientFire = true;
		ClientFire(Value);
		if ( bRapidFire || (FiringSpeed > 0) )
		{
			Pawn(Owner).PlayRecoil(FiringSpeed);
		}
		if ( bInstantHit )
		{
			TraceFire(Value);
		}
		else
		{
			ProjectileFire(ProjectileClass, ProjectileSpeed, bWarnTarget);
		}
	}
}


// Overwrite of Weapon.Finish
// Finish a firing sequence
function Finish()
{
	local Pawn PawnOwner;
	local bool bForce, bForceAlt;
	local int	nAmmoPerShot;
	local bool bAltMode;

	bAltMode = IsInState('AltFiring');

	// Check for semi-auto behaviour and reset the bFire indicator
	if( (((m_bSemiAuto) && !bAltMode) || ((m_bSemiAutoAlt) && bAltMode) ) && (Pawn(Owner).bFire != 0))
	{
		Pawn(Owner).bFire = 0;
	}

	bForce = bForceFire;
	bForceAlt = bForceAltFire;
	bForceFire = false;
	bForceAltFire = false;

	if ( bChangeWeapon )
	{
		GotoState('DownWeapon');
		return;
	}

	if(!bAltMode)
		nAmmoPerShot = AmmoPerShot;
	else
		nAmmoPerShot = AltAmmoPerShot;

	PawnOwner = Pawn(Owner);
	if ( PawnOwner == None )
		return;

	if ( PlayerPawn(Owner) != None )
	{
		if ( (AmmoType != None) && (AmmoType.AmmoAmount<nAmmoPerShot) )
		{
			PawnOwner.StopFiring();
			PawnOwner.SwitchToBestWeapon();

			if ( bChangeWeapon )
				GotoState('DownWeapon');
			else
				GotoState('Idle');
		}
		else if ( (PawnOwner.bFire != 0) && (FRand() < RefireRate) )
			Global.Fire(0);
		else if ( (PawnOwner.bAltFire != 0) && (FRand() < AltRefireRate) )
			Global.AltFire(0);
		else
		{
			PawnOwner.StopFiring();
			GotoState('Idle');
		}
		return;
	}
	if ( ((AmmoType != None) && (AmmoType.AmmoAmount<=0)) || (PawnOwner.Weapon != self) )
		GotoState('Idle');
	else if ( (PawnOwner.bFire!=0) || bForce )
		Global.Fire(0);
	else if ( (PawnOwner.bAltFire!=0) || bForceAlt )
		Global.AltFire(0);
	else
		GotoState('Idle');
}


//
// Set up respawn waiting if desired.
//
function SetRespawn()
{
//log("%%% setrespawn");
	if( Level.Game.ShouldRespawn(self) )
	{
//log("%%% setrespawn: sleeping");
		GotoState('Sleeping');
	}
	else
	{
//log("%%% setrespawn: destroy");
		Destroy();
	}
}

// Either give this inventory to player Other, or spawn a copy
// and give it to the player Other, setting up original to be respawned.
// Also add Ammo to Other's inventory if it doesn't already exist
//
function inventory SpawnCopy( pawn Other )
{
	local inventory Copy;
	local Weapon newWeapon;
//log("%%%Weapon: spawncopy ");
	if( Level.Game.ShouldRespawn(self) )
	{
//log("%%%Weapon: spawncopy ShouldRespawn: true");
		Copy = spawn(Class,Other,,,rot(0,0,0));
		Copy.Tag           = Tag;
		Copy.Event         = Event;
		if ( !bWeaponStay )
		{
//log("%%%Weapon: spawncopy bWeaponStay: true");
			GotoState('Sleeping');
		}
	}
	else
		Copy = self;

	Copy.RespawnTime = 0.0;
	Copy.bHeldItem = true;
	Copy.bTossedOut = false;
	Copy.GiveTo( Other );
	newWeapon = Weapon(Copy);
	newWeapon.Instigator = Other;
	newWeapon.GiveAmmo(Other);
	newWeapon.SetSwitchPriority(Other);
	if ( !Other.bNeverSwitchOnPickup )
		newWeapon.WeaponSet(Other);
	newWeapon.AmbientGlow = 0;
	return newWeapon;
}

state Idle
{
	function AnimEnd()
	{
		PlayIdleAnim();
	}

	function bool PutDown()
	{
		GotoState('DownWeapon');
		return True;
	}

Begin:
	bPointing=False;
	if ( (AmmoType != None) && (AmmoType.AmmoAmount<=0) ) 
		if(!Pawn(Owner).SwitchToBestWeapon())  //Goto Weapon that has Ammo
		{
			if(None == Weapon(Pawn(Owner).FindInventoryType(class'SFNullGun')))
			{
				// Spawn the null gun
				Pawn(Owner).PendingWeapon = spawn(class'SFNullGun', Owner);
			}
			PutDown();
		}
	if ( Pawn(Owner).bFire!=0 ) Fire(0.0);
	if ( Pawn(Owner).bAltFire!=0 ) AltFire(0.0);	
	Disable('AnimEnd');
	PlayIdleAnim();
}



// Firing speed should match fDesiredRate, since it determines the recoil animation on the player

defaultproperties
{
     MaxTargetRange=1000
     MaxTargetRangeAlt=1000
     CreateTag=-1
     fNormalRate=0.330000
     fDesiredRate=0.330000
     fAltDesiredRate=0.330000
     fDamage=20.000000
     fAltDamage=20.000000
     AmmoPerShot=1
     AltAmmoPerShot=1
     LaserSightUpgradeMessage="Upgraded with Laser Sight"
     UpgradeWeaponSound=Sound'Botpack.Pickups.UTHealth'
     m_fTrailEffectIntervallSize=135.000000
     m_fTangentCalc=1000.000000
     m_fTangentCalcAlt=1000.000000
     FiringSpeed=0.330000
     MyDamageType='
     aimerror=1050.000000
     FireSound=Sound'Botpack.enforcer.E_Shot'
     AutoSwitchPriority=0
     InventoryGroup=0
     bRotatingPickup=False
     PickupMessageClass=None
     CollisionRadius=24.000000
     CollisionHeight=10.000000
}